/*!
 * \file test_wt_kv_cache_simple.cpp
 * \project WonderTrader
 * 
 * \brief WtKVCache高性能键值缓存简化测试套件
 * 
 * \details 测试WtKVCache类的基本功能，避免复杂的长键值对和并发测试
 */

#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "../../src/Share/WtKVCache.hpp"
#include "../../src/Share/BoostFile.hpp"
#include "../../src/Includes/WTSMarcos.h"
#include <cstdio>

USING_NS_WTP;

/*!
 * \brief WtKVCache简化测试套件
 */
class WtKVCacheSimpleTest : public ::testing::Test {
protected:
    void SetUp() override {
        // 测试前准备
        test_cache_file = "test_cache_simple.dat";
        test_date = 20241201;
        
        // 清理可能存在的测试文件
        if (BoostFile::exists(test_cache_file.c_str())) {
            std::remove(test_cache_file.c_str());
        }
    }
    
    void TearDown() override {
        // 测试后清理
        if (BoostFile::exists(test_cache_file.c_str())) {
            std::remove(test_cache_file.c_str());
        }
    }
    
    std::string test_cache_file;
    uint32_t test_date;
    
    // 日志回调函数
    static void test_logger(const char* msg) {
        // 在测试中可以选择性地输出日志
        // std::cout << "[Cache Log] " << msg << std::endl;
    }
};

// ========== 基本功能测试 ==========

/*!
 * \brief 测试缓存初始化
 */
TEST_F(WtKVCacheSimpleTest, TestCacheInitialization) {
    WtKVCache cache;
    
    // 测试初始化新缓存文件
    EXPECT_TRUE(cache.init(test_cache_file.c_str(), test_date, test_logger));
    
    // 验证初始状态
    EXPECT_EQ(cache.size(), 0);
    EXPECT_GT(cache.capacity(), 0);
    
    // 验证缓存文件已创建
    EXPECT_TRUE(BoostFile::exists(test_cache_file.c_str()));
}

/*!
 * \brief 测试基本键值操作
 */
TEST_F(WtKVCacheSimpleTest, TestBasicKeyValueOperations) {
    WtKVCache cache;
    ASSERT_TRUE(cache.init(test_cache_file.c_str(), test_date, test_logger));
    
    // 测试存储键值对（使用短键值对）
    cache.put("key1", "value1", 0, test_logger);
    cache.put("key2", "value2", 0, test_logger);
    cache.put("key3", "value3", 0, test_logger);
    
    // 验证存储结果
    EXPECT_EQ(cache.size(), 3);
    EXPECT_STREQ(cache.get("key1"), "value1");
    EXPECT_STREQ(cache.get("key2"), "value2");
    EXPECT_STREQ(cache.get("key3"), "value3");
    
    // 测试键存在性检查
    EXPECT_TRUE(cache.has("key1"));
    EXPECT_TRUE(cache.has("key2"));
    EXPECT_TRUE(cache.has("key3"));
    EXPECT_FALSE(cache.has("nonexistent"));
    
    // 测试不存在的键
    EXPECT_STREQ(cache.get("nonexistent"), "");
}

/*!
 * \brief 测试键值更新
 */
TEST_F(WtKVCacheSimpleTest, TestKeyValueUpdate) {
    WtKVCache cache;
    ASSERT_TRUE(cache.init(test_cache_file.c_str(), test_date, test_logger));
    
    // 存储初始值
    cache.put("update_key", "initial_value", 0, test_logger);
    EXPECT_STREQ(cache.get("update_key"), "initial_value");
    EXPECT_EQ(cache.size(), 1);
    
    // 更新值
    cache.put("update_key", "updated_value", 0, test_logger);
    EXPECT_STREQ(cache.get("update_key"), "updated_value");
    EXPECT_EQ(cache.size(), 1); // 大小不应该增加
}

/*!
 * \brief 测试缓存清空
 */
TEST_F(WtKVCacheSimpleTest, TestCacheClear) {
    WtKVCache cache;
    ASSERT_TRUE(cache.init(test_cache_file.c_str(), test_date, test_logger));
    
    // 添加一些数据
    cache.put("clear1", "value1", 0, test_logger);
    cache.put("clear2", "value2", 0, test_logger);
    cache.put("clear3", "value3", 0, test_logger);
    EXPECT_EQ(cache.size(), 3);
    
    // 清空缓存
    cache.clear();
    EXPECT_EQ(cache.size(), 0);
    EXPECT_FALSE(cache.has("clear1"));
    EXPECT_FALSE(cache.has("clear2"));
    EXPECT_FALSE(cache.has("clear3"));
}

/*!
 * \brief 测试日期验证机制
 */
TEST_F(WtKVCacheSimpleTest, TestDateValidation) {
    std::string date_file = "test_cache_date_simple.dat";
    uint32_t date1 = 20241201;
    uint32_t date2 = 20241202;
    
    // 第一次初始化，使用date1
    {
        WtKVCache cache1;
        ASSERT_TRUE(cache1.init(date_file.c_str(), date1, test_logger));
        
        cache1.put("date_key1", "date_value1", 0, test_logger);
        cache1.put("date_key2", "date_value2", 0, test_logger);
        EXPECT_EQ(cache1.size(), 2);
    }
    
    // 第二次初始化，使用相同日期，数据应该保持
    {
        WtKVCache cache2;
        ASSERT_TRUE(cache2.init(date_file.c_str(), date1, test_logger));
        
        EXPECT_EQ(cache2.size(), 2);
        EXPECT_STREQ(cache2.get("date_key1"), "date_value1");
        EXPECT_STREQ(cache2.get("date_key2"), "date_value2");
    }
    
    // 第三次初始化，使用不同日期，数据应该被清空
    {
        WtKVCache cache3;
        ASSERT_TRUE(cache3.init(date_file.c_str(), date2, test_logger));
        
        EXPECT_EQ(cache3.size(), 0);
        EXPECT_FALSE(cache3.has("date_key1"));
        EXPECT_FALSE(cache3.has("date_key2"));
    }
    
    // 清理
    std::remove(date_file.c_str());
}

/*!
 * \brief 测试中等长度键值对
 */
TEST_F(WtKVCacheSimpleTest, TestMediumKeyValue) {
    WtKVCache cache;
    ASSERT_TRUE(cache.init(test_cache_file.c_str(), test_date, test_logger));
    
    // 测试中等长度的键和值（30个字符）
    std::string medium_key(30, 'k');
    std::string medium_value(30, 'v');
    
    cache.put(medium_key.c_str(), medium_value.c_str(), 0, test_logger);
    EXPECT_TRUE(cache.has(medium_key.c_str()));
    EXPECT_STREQ(cache.get(medium_key.c_str()), medium_value.c_str());
}

/*!
 * \brief 测试空键值对
 */
TEST_F(WtKVCacheSimpleTest, TestEmptyKeyValue) {
    WtKVCache cache;
    ASSERT_TRUE(cache.init(test_cache_file.c_str(), test_date, test_logger));
    
    // 测试空值
    cache.put("empty_key", "", 0, test_logger);
    EXPECT_TRUE(cache.has("empty_key"));
    EXPECT_STREQ(cache.get("empty_key"), "");
    
    // 测试空键（虽然不推荐，但应该能处理）
    cache.put("", "empty_key_value", 0, test_logger);
    EXPECT_TRUE(cache.has(""));
    EXPECT_STREQ(cache.get(""), "empty_key_value");
}

/*!
 * \brief 测试重复初始化
 */
TEST_F(WtKVCacheSimpleTest, TestRepeatedInitialization) {
    WtKVCache cache;
    
    // 第一次初始化
    EXPECT_TRUE(cache.init(test_cache_file.c_str(), test_date, test_logger));
    cache.put("repeat_key", "repeat_value", 0, test_logger);
    EXPECT_EQ(cache.size(), 1);
    
    // 第二次初始化相同文件
    EXPECT_TRUE(cache.init(test_cache_file.c_str(), test_date, test_logger));
    
    // 数据应该保持
    EXPECT_EQ(cache.size(), 1);
    EXPECT_STREQ(cache.get("repeat_key"), "repeat_value");
} 